/**
 * 计算引擎：支持公式解析、变量替换、内置函数（ROUND/AVG/SUM/max）
 * 适配场景：
 * 1. 单个计算参数（如表观密度：ROUND( mass / max(0.001, volume) * 1000, 0 )）
 * 2. 汇总计算（如多试件密度平均值：ROUND( AVG( group_GRP001.map(item => item.density || 0) ), 0 )）
 * 支持：数组访问、对象属性、动态试件数量、小数计算、避免除以0
 */

// 内置计算函数库（覆盖所有用到的函数）
const calcFunctions = {
  /**
   * 四舍五入函数
   * @param {number} num - 待处理数值
   * @param {number} precision - 保留小数位数（默认0）
   * @returns {number|string} 处理后结果（无效值返回空字符串）
   */
  ROUND: (num, precision = 0) => {
    if (isNaN(num) || num === undefined || num === '' || num === null) return '';
    return Number(parseFloat(num).toFixed(precision));
  },

  /**
   * 最大值函数（避免除以0）
   * @param  {...any} args - 待比较的值列表
   * @returns {number} 最大值（无有效值时返回0.001）
   */
  max: (...args) => {
    const validArgs = args.flat().filter(item => 
      !isNaN(item) && item !== undefined && item !== '' && item !== null
    );
    return validArgs.length > 0 ? Math.max(...validArgs) : 0.001;
  },

  /**
   * 平均值函数（支持数组/多参数，过滤无效值）
   * @param  {...any} args - 待计算平均值的值（可传数组或多个参数）
   * @returns {number|string} 平均值（无有效值时返回空字符串）
   */
  AVG: (...args) => {
    const validArgs = args.flat().filter(item => 
      !isNaN(item) && item !== undefined && item !== '' && item !== null && item !== 0
    );
    return validArgs.length > 0 
      ? validArgs.reduce((total, curr) => total + curr, 0) / validArgs.length 
      : '';
  },

  /**
   * 求和函数（支持数组/多参数，过滤无效值）
   * @param  {...any} args - 待求和的值（可传数组或多个参数）
   * @returns {number|string} 总和（无有效值时返回空字符串）
   */
  SUM: (...args) => {
    const validArgs = args.flat().filter(item => 
      !isNaN(item) && item !== undefined && item !== '' && item !== null && item !== 0
    );
    return validArgs.length > 0 
      ? validArgs.reduce((total, curr) => total + curr, 0) 
      : '';
  }
};

/**
 * 变量解析函数：将公式中的变量路径替换为实际值
 * 支持变量格式：
 * - 单个变量：mass、volume
 * - 数组+对象属性：group_GRP001[0].density、group_GRP001.map(...)
 * @param {string} expr - 待解析的公式
 * @param {object} data - 变量上下文（表单数据）
 * @returns {string} 解析后的公式
 */
const resolveVariables = (expr, data) => {
  if (!expr || typeof expr !== 'string') return expr;

  // 正则匹配变量路径：排除内置函数（ROUND/AVG/SUM/max/map），支持数组+对象属性
   const variableRegex = /\b(?!ROUND|AVG|SUM|max|map|\d+\.?\d*)\w+(\[\d+\])*(\.\w+)*\b/g;

  return expr.replace(variableRegex, (variablePath) => {
    try {
      let value = data;
      // 拆分路径片段（处理 [0] 和 .属性名）
      const pathSegments = variablePath.split(/(\[\d+\]|\.)/).filter(seg => seg !== '' && seg !== '.');

      for (const seg of pathSegments) {
        if (!value) break; // 路径无效，终止解析
        if (seg.startsWith('[')) {
          // 处理数组索引（如 [0] → 转为数字索引）
          const index = parseInt(seg.slice(1, -1), 10);
          value = Array.isArray(value) ? value[index] : undefined;
        } else {
          // 处理对象属性（如 group_GRP001、density）
          value = value[seg];
        }
      }

      // 特殊处理：数组类型保留原结构（支持 map 方法）
      if (Array.isArray(value)) {
        console.log(`[变量解析] 数组路径：${variablePath} → 长度=${value.length}`);
        return JSON.stringify(value); // 转为JSON字符串，eval时自动还原为数组
      }

      // 普通变量日志
      console.log(`[变量解析] 普通变量：${variablePath} → 值=${value}（类型=${typeof value}）`);

      // 无效值处理：返回0避免计算报错
      if (value === undefined || value === null || value === '' || isNaN(Number(value))) {
        console.warn(`[变量解析] 变量${variablePath}值无效，返回0`);
        return '0';
      }

      // 有效数字：转为字符串拼接公式
      return String(Number(value));
    } catch (error) {
      console.warn(`[变量解析] 路径${variablePath}解析失败`, error);
      return '0';
    }
  });
};

/**
 * 核心计算方法：解析公式并执行计算
 * @param {string} expr - 计算表达式（如 "ROUND( mass / max(0.001, volume) * 1000, 0 )"）
 * @param {object} data - 变量上下文（表单数据）
 * @returns {number|string} 计算结果（无效时返回空字符串）
 */
export const calcParamValue = (expr, data) => {
  let resolvedExpr = '';
  try {
    // 1. 输入校验+日志
    console.log('\n==================================================');
    console.log(`[计算开始] 原公式：${expr}`);
    console.log(`[计算上下文] data：`, JSON.parse(JSON.stringify(data))); // 深拷贝避免污染原数据

    if (!expr || typeof expr !== 'string' || !data || typeof data !== 'object') {
      console.warn(`[计算失败] 表达式或数据格式无效`);
      return '';
    }

    // 2. 解析变量（替换公式中的变量为实际值）
    resolvedExpr = resolveVariables(expr, data);
    console.log(`[计算中] 解析后公式：${resolvedExpr}`);

    // 3. 包装表达式：注入所有内置函数（避免漏注入）
    const wrappedExpr = `(function(ROUND, max, AVG, SUM) {
      return ${resolvedExpr};
    })`;

    // 4. 执行计算（安全执行包装后的表达式）
    const calculate = eval(wrappedExpr);
    const result = calculate(
      calcFunctions.ROUND,
      calcFunctions.max,
      calcFunctions.AVG,
      calcFunctions.SUM
    );

    // 5. 结果日志+处理
    console.log(`[计算成功] 结果：${result}`);
    console.log('==================================================\n');

    // 过滤无效结果（返回空字符串）
    return isNaN(Number(result)) || result === undefined || result === '' || result === null 
      ? '' 
      : Number(result);

  } catch (error) {
    // 异常捕获+详细日志
    console.error('\n==================================================');
    console.error(`[计算失败] 原公式：${expr}`);
    console.error(`[计算失败] 解析后公式：${resolvedExpr}`);
    console.error(`[计算失败] 错误信息：`, error);
    console.error('==================================================\n');
    return '';
  }
};